package com.magicborrow.utils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.text.TextUtils;
import android.view.View;
import android.widget.ImageView;

import com.magicborrow.R;
import com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache;
import com.nostra13.universalimageloader.cache.disc.naming.HashCodeFileNameGenerator;
import com.nostra13.universalimageloader.cache.disc.naming.Md5FileNameGenerator;
import com.nostra13.universalimageloader.cache.memory.impl.LruMemoryCache;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.core.decode.BaseImageDecoder;
import com.nostra13.universalimageloader.core.display.BitmapDisplayer;
import com.nostra13.universalimageloader.core.display.RoundedBitmapDisplayer;
import com.nostra13.universalimageloader.core.download.BaseImageDownloader;
import com.nostra13.universalimageloader.core.listener.SimpleImageLoadingListener;
import com.nostra13.universalimageloader.utils.StorageUtils;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;


@SuppressLint("HandlerLeak")
public class ImageLoadUtil {

	// 磁盘缓存的两种限制方式: 限制最大的条数，限制最大的体积
	public static final int MAX_DISK_CACHE_FILE_COUNT = 100;
	public static final int MAX_DISK_CACHE_FILE_SIZE = 30 * 1024 * 1024;
	public static final int MAX_POOL_THREAD_SIZE = 5;
	public static ImageLoader imageLoader = null;

	public enum ImageStyle {
		CIRCLE_MEMBER, USER_MEMBER, PHOTO;
	}

	// 初始化 图片加载器
	public static void configuration(Context context) {
        DisplayImageOptions imageOptions = new DisplayImageOptions.Builder()
                //.showImageOnLoading(R.drawable.ic_picture_loading)
                //.showImageOnFail(R.drawable.ic_picture_loadfailed)
				.showImageOnLoading(R.mipmap.img_default)
				.showImageOnFail(R.mipmap.img_default)
                .cacheInMemory(true).cacheOnDisk(true)
                .resetViewBeforeLoading(true).considerExifParams(false)
                .bitmapConfig(Bitmap.Config.RGB_565).build();

        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(
                context)
                .memoryCacheExtraOptions(400, 400)
                        // default = device screen dimensions
                .diskCacheExtraOptions(400, 400, null)
                .threadPoolSize(5)
                        // default Thread.NORM_PRIORITY - 1
                .threadPriority(Thread.NORM_PRIORITY)
                        // default FIFO
                .tasksProcessingOrder(QueueProcessingType.LIFO)
                        // default
                .denyCacheImageMultipleSizesInMemory()
                .memoryCache(new LruMemoryCache(2 * 1024 * 1024))
                .memoryCacheSize(2 * 1024 * 1024)
                .memoryCacheSizePercentage(13)
                        // default
                .diskCache(
                        new UnlimitedDiscCache(StorageUtils.getCacheDirectory(
                                context, true)))
                        // default
                .diskCacheSize(50 * 1024 * 1024).diskCacheFileCount(100)
                .diskCacheFileNameGenerator(new HashCodeFileNameGenerator())
                        // default
                .imageDownloader(new BaseImageDownloader(context))
                        // default
                .imageDecoder(new BaseImageDecoder(false))
                        // default
                .defaultDisplayImageOptions(DisplayImageOptions.createSimple())
                        // default
                .defaultDisplayImageOptions(imageOptions).build();

        ImageLoader.getInstance().init(config);
        imageLoader = ImageLoader.getInstance();

//		if (imageLoader == null) {
//			ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
//					.threadPriority(Thread.NORM_PRIORITY - 2).denyCacheImageMultipleSizesInMemory()
//					.discCacheSize(MAX_DISK_CACHE_FILE_SIZE)
//					// .discCacheFileCount(MAX_DISK_CACHE_FILE_COUNT)
//					.discCacheFileNameGenerator(new Md5FileNameGenerator())
//					.tasksProcessingOrder(QueueProcessingType.LIFO)
//					// .writeDebugLogs() // 输入日志，打包发布的时候注释掉
//					.build();
//
//			ImageLoader.getInstance().init(config);
//
//			imageLoader = ImageLoader.getInstance();
//		}
	}

	/**
	 * 构造图片显示的配置选项
	 * 
	 * @param placeHolderImgRes
	 *            默认的占位显示图片
	 * @param emptyUrlImgRes
	 *            空链接显示的图片
	 * @param failedImgRes
	 *            加载失败显示的图片
	 * @param cacheInMemory
	 *            是否内存缓存，图片过大，建议不要内存缓存
	 * @return
	 */
	private static DisplayImageOptions constructDisplayOption(String url, int placeHolderImgRes, int emptyUrlImgRes,
			int failedImgRes, boolean cacheInMemory, BitmapDisplayer displayer) {
		DisplayImageOptions.Builder bulider = new DisplayImageOptions.Builder();
		bulider.cacheOnDisc(true); // 默认开启磁盘缓存 缓存在默认位置
		// /sdcard/Android/data/[package_name]/cache
		bulider.cacheInMemory(cacheInMemory);
		bulider.resetViewBeforeLoading(true);
		bulider.bitmapConfig(Bitmap.Config.RGB_565);
		// bulider.displayer(new FadeInBitmapDisplayer(200));//加载动画
		if (displayer != null) {
			bulider.displayer(displayer);
		}

		if (placeHolderImgRes > 0) {
			bulider.showStubImage(placeHolderImgRes);
		}

		if (emptyUrlImgRes > 0) {
			bulider.showImageForEmptyUri(emptyUrlImgRes);
		}

		if (failedImgRes > 0) {
			bulider.showImageOnFail(failedImgRes);
		}

		return bulider.build();
	}

	/**
	 * *
	 * 
	 * @param imageView
	 *            显示图片的组件
	 * @param url
	 *            图片加载的URL
	 * @param
	 *
	 */
	public static void loadImage(ImageView imageView, String url, ImageStyle imageStyle) {
		int loadImageRes = 0;
		if (imageStyle == ImageStyle.USER_MEMBER) {
			//loadImageRes = R.drawable.icon_default_avatar_2;
		} else if (imageStyle == ImageStyle.CIRCLE_MEMBER) {
			//loadImageRes = R.drawable.icon_default_avatar_2;
		} else if (imageStyle == ImageStyle.PHOTO) {
			loadImageRes = R.mipmap.empty_photo;
		}
		loadImage(imageView, url, loadImageRes);
	}

	/**
	 * 加载显示图片
	 * 
	 * @param imageView
	 *            显示图片的组件
	 * @param url
	 *            图片加载的URL
	 * @param placeHolderImg
	 *            默认的占位显示图片
	 */
	public static void loadImage(ImageView imageView, String url, int placeHolderImg) {
		loadImage(imageView, url, placeHolderImg, true);
	}

	/**
	 * 加载显示图片
	 * 
	 * @param imageView
	 *            显示图片的组件
	 * @param url
	 *            图片加载的URL
	 * @param placeHolderImg
	 *            默认的占位显示图片
	 * @param cacheInMemory
	 *            是否将图片缓存到内存中(大图不建议缓存到内存中)
	 */
	public static void loadImage(ImageView imageView, String url, int placeHolderImg, boolean cacheInMemory) {
		loadImage(imageView, url, placeHolderImg, 0, 0, cacheInMemory, null);
	}

	/**
	 * 绘制圆形头像 0表示没有边框
	 * 
	 * @param imageView
	 * @param url
	 * @param
	 * @param color
	 *            请用getresrouce.getcolor
	 */
	public static void loadCircleImage(ImageView imageView, String url, int color) {
//		loadImage(imageView, url, R.drawable.icon_default_cricle_contacts, 0, 0, true, new CircleDisplayer(color));
	}

	public static void loadRoundImage(ImageView imageView, String url, int defaultImg) {
		loadImage(imageView, url, defaultImg, 0, 0, true, new RoundedBitmapDisplayer(5));
	}

	/**
	 * 加载显示图片
	 * 
	 * @param imageView
	 *            显示图片的组件
	 * @param url
	 *            图片加载的URL
	 * @param placeHolderImg
	 *            默认的占位显示图片
	 * @param emptyUrlImgRes
	 *            空链接显示的图片，不定义请置 0
	 * @param failedImgRes
	 *            加载失败显示的图片，不定义请置 0
	 * @param cacheInMemory
	 *            是否将图片缓存到内存中 (大图不建议缓存到内存中)
	 */
	public static void loadImage(ImageView imageView, String url, int placeHolderImg, int emptyUrlImgRes,
			int failedImgRes, boolean cacheInMemory, BitmapDisplayer displayer) {
		DisplayImageOptions option = constructDisplayOption(url, placeHolderImg, emptyUrlImgRes, failedImgRes,
				cacheInMemory, displayer);
		if (TextUtils.isEmpty(url)
				|| (!url.endsWith(".jpg") && !url.endsWith(".jpeg") && !url.endsWith(".png") && !url.endsWith(".JPG")
						&& !url.endsWith(".JPEG") && !url.endsWith(".PNG"))) {
			if (placeHolderImg != 0) {
				imageView.setImageResource(placeHolderImg);
			}
			return;
		}
		imageLoader.displayImage(url, imageView, option);
	}

	/**
	 * @param url
	 *            图片加载的URL
	 * @param imageLoadCallbBack
	 *            返回图片的bitmap
	 */
	public static void loadBitmapImage(String url, final ImageLoadInterface.ImageLoadCallBack imageLoadCallbBack) {
		DisplayImageOptions option = constructDisplayOption(url, 0, 0, 0, true, null);
		imageLoader.loadImage(url, option, new SimpleImageLoadingListener() {

			@Override
			public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
				super.onLoadingComplete(imageUri, view, loadedImage);
				imageLoadCallbBack.callBack(loadedImage);
			}

		});
	}

	/**
	 * 判断网络图片是否存在，而不用去缓存这个图片
	 * 
	 * @param url
	 *            图片地址
	 * @return
	 */
	public static void isImageAvailable(final String url, final ImageLoadInterface.ImageAvailableCallBack availableCallBack) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				availableCallBack.clallBack(connectImageUrl(url));
			}
		}).start();

	}

	/**
	 * 从两个URL地址中判断哪个有效，返回有效的那一个，两个都无效返回默认
	 * 
	 * @param url1
	 * @param url2
	 * @param defalutUrl
	 * @param chooseCallBack
	 */
	public static void chooseAvailableImage(final String url1, final String url2, final String defalutUrl,
			final ImageLoadInterface.ChooseImageCallBack chooseCallBack) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				String result = defalutUrl;
				boolean url1Reslut = connectImageUrl(url1);
				if (url1Reslut) {
					result = url1;
				} else {
					boolean url2Reslut = connectImageUrl(url2);
					if (url2Reslut) {
						result = url2;
					}
				}
				chooseCallBack.clallBack(result);
			}
		}).start();

	}

	public static void loadImage(String url) {
		imageLoader.loadImage(url, null);
	}
	
	/**
	 * 尝试获取图片资源
	 * 
	 * @param url
	 * @return
	 */
	private static boolean connectImageUrl(String url) {
		try {
			URL imageUrl = new URL(url);// 创建URL对象。
			URLConnection uc = imageUrl.openConnection();// 创建一个连接对象。
			InputStream in = uc.getInputStream();// 获取连接对象输入字节流。如果地址无效则会抛出异常。
			in.close();
			return true;
		} catch (Exception e) {
			//e.printStackTrace();
			//Log.e("图片资源" + url + "不存在");
			return false;
		}
	}

	public static String getPath4Url(Context context, String url) {
		File file = StorageUtils.getIndividualCacheDirectory(context);
		String filePath = file.getAbsolutePath() + "/" + getName4Url(url);
		return filePath;
	}

	/**
	 * 从内存卡中异步加载本地图片
	 *
	 * @param uri
	 * @param imageView
	 */
	public static void displayFromSDCard(String uri, ImageView imageView) {
		// String imageUri = "file:///mnt/sdcard/image.png"; // from SD card
		ImageLoader.getInstance().displayImage("file://" + uri, imageView);
	}

	/**
	 * 从assets文件夹中异步加载图片
	 *
	 * @param imageName
	 *            图片名称，带后缀的，例如：1.png
	 * @param imageView
	 */
	public void dispalyFromAssets(String imageName, ImageView imageView) {
		// String imageUri = "assets://image.png"; // from assets
		ImageLoader.getInstance().displayImage("assets://" + imageName,
				imageView);
	}

	/**
	 * 从drawable中异步加载本地图片
	 *
	 * @param imageId
	 * @param imageView
	 */
	public void displayFromDrawable(int imageId, ImageView imageView) {
		// String imageUri = "drawable://" + R.drawable.image; // from drawables
		// (only images, non-9patch)
		ImageLoader.getInstance().displayImage("drawable://" + imageId,
				imageView);
	}

	/**
	 * 从内容提提供者中抓取图片
	 */
	public void displayFromContent(String uri, ImageView imageView) {
		// String imageUri = "content://media/external/audio/albumart/13"; //
		// from content provider
		ImageLoader.getInstance().displayImage("content://" + uri, imageView);
	}


	public static String getName4Url(String url) {
		return new Md5FileNameGenerator().generate(url);
	}
}
